Embedded devices generally comprise objects that contain an embedded computing system, which may be enclosed by the object. The embedded computer system may be designed with a specific use in mind, or the embedded computer system may be at least in part general-purpose in the sense that a user may be enabled to install software in it. An embedded computer system may be based on a microcontroller or microprocessor CPU, for example.
Embedded devices may comprise one or more processors, user interfaces and displays, such that a user may interact with the device using the user interface. The user interface may comprise buttons, for example. An embedded device may comprise a connectivity function configured to communicate with a communications network, such as, for example, a wireless communications network.
More complex embedded devices, such as cellular telephones, may allow a user to install applications into a memory, such as, for example, a solid-state memory, comprised in the device. Embedded devices are frequently resource-constrained when compared to desktop or laptop computers. For example, memory capacity may be more limited than in desktop or laptop computers, processor computational capacity may be lower and energy may be available from a battery. The battery, which may be small, may be rechargeable.
An embedded device may be enabled to receive from a communications network information relating to, for example, a current time and current time zone. In the context of multiple processors in embedded devices, also the communication between processors and the memory they use becomes an issue. A fundamental question of traditional parallel computer design is to select between the two parallel computing paradigms:
Shared Memory—Usually via threads, all processors can access all memory directly at any time, and    Distributed Memory—A processor can access only its own memory, but processors can share data using message passing, as in the NUMA (Non Uniform Memory Access) architecture.
For various reasons and design considerations, an embedded system may comprise more than one processor and/or microcontroller. In consumer devices, one of the processors may be dedicated for specific tasks, such as for digital signal processing (DSP) or graphics processing, or the processors may be have multiple cores for processing power. However, in small consumer devices, where conserving battery power is a task competing with power requirements, the number of processors must usually be kept as small and their power consumption as low as possible. As the development is towards embedded and distributed computing, which may include a multitude of sensors and connectivity needs with other peripheral devices, the traditional one-processor approach is not always possible. In practice the processors may, although embedded, be more like independent computers with a variety of processes and tasks to perform.
For example, a multitude of sensors, or a sensor hub containing or supporting such sensors, may be connected to a low power microcontroller running its independent applications for collecting and displaying basic information. A main processing unit running more computing-intensive applications, like color displays and graphics-intensive software, may be then waked up only on request, thus saving energy.
Asynchronous operation accounts for unpredictability in events and their timing. Concurrency may occur when peripherals like sensors share and may interrupt the same processor, or when multiple processors share the same memory. A major job of an operating system is to manage concurrent operations and the running applications. Concurrency control has however also become an integral part of many applications through multi-thread processes and their memory sharing algorithms that are working on memory pools or heaps.
There is a general problem in implementing communication in embedded multi-processor solutions in devices, i.e. how to enable the processors and their applications running on them to send, share and retrieve information between themselves, both on an ad-hoc (asynchronous) basis and concurrently. There are also specific problems in low-power embedded devices regarding the division of tasks and optimization of the power consumption of the processors.
It is an object of at least some of the embodiments of the present invention to provide a solution to interoperability and data sharing issues relating to embedded systems. The inventive idea is based on the use of a common information resource, hereafter a whiteboard, which is shared by different processors, processes and/or threads. The processes may be running in embedded devices themselves, on servers or on the internet. The whiteboard may be shared by a multitude of such devices. By managing the resources of such a memory e.g. by formatting and mapping techniques, naming and name space conventions and/or interface segmentation, the whiteboard may be used to improve interoperability and data sharing between different processors such as identified above, and the applications running on them.